/*
RECCLI.C

The record application's client window and its components
*/


#include <p_std.h>
#include <p_sys.h>
#include <p_date.h>
#include <epoc.h>
#include <p_config.h>
#include <record.g>
#include <hwim.h>
#include <record.rsg>
#include <fonts.h>
#include <olib.h>

GLREF_D PR_RECWSERV * const w_ws;
GLREF_D PR_APPMAN * const w_am;
GLREF_D PR_RECENG * const receng;

#define TIMEBAR_HEIGHT 13

#define RECBUT_HIDE_DRAW  0
#define RECBUT_HIDE_HIDE  1
#define RECBUT_HIDE_CLEAR 2

#define RECBUT_HALF_WIDTH 34
#define RECBUT_HALF_HEIGHT 10
#define RECBUT_ASCENT 16
#define RECBUT_MARGIN 20

#define RECCLI_NBUTTONS 5
#define RECCLI_3BUT_MASK 0x7        /* 1st 3 buttons */
#define RECCLI_STOP_MASK 0x8        /* 4th button */
#define RECCLI_START_MASK 0x10      /* 5th button */

LOCAL_D UBYTE recbut_hide[RECCLI_NBUTTONS]=
    {RECBUT_HIDE_CLEAR,RECBUT_HIDE_HIDE,RECBUT_HIDE_CLEAR,RECBUT_HIDE_HIDE,RECBUT_HIDE_HIDE};

LOCAL_C TEXT *NextZTS(TEXT *str)
    {
    while (*str++);
    return(str);
    }

LOCAL_C VOID StartFRC(PR_TIMEBAR *self)
    {
    UWORD tick,mode;

    mode=E_FRC_REPEATING;
    tick=100;
    p_iow4(self->active.pcb,P_FSTART,&mode,&tick);
    }

LOCAL_C INT BarLength(PR_TIMEBAR *self)
    {
    INT width;

    width=self->timebar.rect.br.x-self->timebar.rect.tl.x-2;
    if (self->timebar.tenths0)
        width-=(UINT)((width*self->timebar.tenths)/self->timebar.tenths0);
    return(width);
    }

LOCAL_C VOID DrawBar(PR_TIMEBAR *self,INT border,INT createGC)
    {
    INT x1,x2;
    P_RECT r;

    x1=self->timebar.x;
    x2=BarLength(self);
    if (x2==x1 && self->timebar.visible && !border)
        return;
    if (createGC)
        gCreateTempGC0(self->timebar.wid);
    r=self->timebar.rect;
    if (!self->timebar.visible)
        {
        gClrRect(&r,G_TRMODE_CLR);
        goto exit;
        }
    if (border)
        gBorderRect(&r,W_BORD_CORNER_1);
    p_insrec(&r,1,1);
    if (x1>x2)
        {
        gClrRect(&r,G_TRMODE_CLR);
        x1=0;
        }
    self->timebar.x=x2;
    r.tl.x+=x1;
    r.br.x=r.tl.x+x2-x1;
    gFillPattern(&r,WS_BITMAP_GREY,G_TRMODE_REPL);
    exit:
    if (createGC)
        {
        gFreeTempGC();
        wFlush();
        }
    }

LOCAL_C VOID DrawButton(PR_RECBUT *self,INT state)
    {
    wDrawButton2(W_BUTTON_TYPE_2,&self->recbut.rect,&self->recbut.inlabel[0],state);
    }

LOCAL_C VOID PrintHeader(PR_RECCLI *self,INT y,TEXT *fmt,...)
    {
    INT len;
    TEXT bb[256];
    P_RECT rect;

    rect.tl.x=8;
    rect.tl.y=y;
    rect.br.x=rect.tl.x+self->reccli.width-16;
    rect.br.y=y+30;
    if (fmt==NULL)
        {
        gClrRect(&rect,G_TRMODE_CLR);
        return;
        }
    len=p_atob(&bb[0],fmt,&fmt+1);
    gPrintBoxText(&rect,20,G_TEXT_ALIGN_CENTRE,0,&bb[0],len);
    }

LOCAL_C VOID HideButtons(PR_RECCLI *self,INT mask)
/*
Set the hidden state of the buttons to hide depending on the bits in mask.
*/
    {
    INT i;

    for (i=0;i<RECCLI_NBUTTONS;i++,mask>>=1)
        self->reccli.recbut[i]->recbut.hide=(mask&1)?recbut_hide[i]:RECBUT_HIDE_DRAW;
    }

LOCAL_C VOID DrawWin(PR_RECCLI *self)
    {
    G_GC gc;

    gc.flags=G_GC_FLAG_BOTH_PLANES;
    gCreateTempGC(self->win.id,G_GC_MASK_GREY,&gc);
    p_send2(self,O_WN_DRAW);
    gFreeTempGC();
    }

LOCAL_C VOID PrintDuration(PR_RECCLI *self,TEXT *buf,ULONG tenths)
    {
    ULONG seconds;
    UINT secs;
    P_DAYSEC ds;
    P_DATE dt;

    seconds=tenths/10;
    if (seconds<60)
        {
        secs=(UINT)seconds;
        p_atos(buf,"%d.%d %s",secs,(UINT)tenths-10*secs,self->reccli.secs);
        return;
        }
    p_sttods(&seconds,&ds);
    p_dstodt(&ds,&dt);
    ds.day-=25567; /* base days at Jan 1 1970 */
    if (ds.day>0)
        { /* show number of days */
        p_atos(buf,"%ld  ",ds.day);
        buf+=p_slen(buf);
        }
    if (dt.hour>0 || ds.day>0)
        { /* show number of hours */
        p_atos(buf,"%02d%c",dt.hour,self->reccli.tsep);
        buf+=p_slen(buf);
        }
    p_atos(buf,"%02d%c%02d",dt.minute,self->reccli.tsep,dt.second);
    }

#pragma METHOD_CALL

METHOD VOID timebar_tb_draw(PR_TIMEBAR *self)
    {
    self->timebar.x=0;
    DrawBar(self,TRUE,FALSE);
    }

METHOD VOID timebar_ao_init(PR_TIMEBAR *self,INT wid,P_RECT *prect)
    {
    self->active.priority=PRIORITY_ACTIVE_REPEATER;
    p_send3(w_am,O_AM_ADD_TASK,self);
    self->timebar.wid=wid;
    self->timebar.rect=*prect;
    }

METHOD VOID timebar_ao_queue(PR_TIMEBAR *self)
    {
    p_ioc3(self->active.pcb,P_FREAD,&self->active.stat);
    self->active.isactive=TRUE;
    }

METHOD INT timebar_ao_run(PR_TIMEBAR *self)
    {
    if (self->active.stat<0)
        { /* possibly because the machine was switched off then on */
        StartFRC(self); /* restart the FRC */
        self->active.stat=0;
        }
    self->timebar.tenths-=self->active.stat;
    if (self->timebar.tenths<=0)
        {
        self->timebar.tenths=0; /* stops re-queue */
        p_close(self->active.pcb);
        self->active.pcb=NULL;
        }
    DrawBar(self,FALSE,TRUE);
    if (self->timebar.tenths)
        timebar_ao_queue(self);
    return(RUN_ACTIVE_USED);
    }

METHOD VOID timebar_tb_start(PR_TIMEBAR *self,ULONG *tenths)
    {
    self->timebar.tenths0=*tenths;
    self->timebar.tenths=self->timebar.tenths0;
    self->timebar.x=0;
    self->timebar.visible=TRUE;
    if (self->timebar.tenths<10 || p_open(&self->active.pcb,"FRC:",-1)<0)
        return;
    StartFRC(self);
    DrawBar(self,TRUE,TRUE);
    timebar_ao_queue(self);
    }

METHOD VOID timebar_tb_stop(PR_TIMEBAR *self)
    {
    p_send2(self,O_AO_CANCEL);
    self->timebar.visible=FALSE;
    p_close(self->active.pcb);
    self->active.pcb=NULL;
    }

METHOD VOID recbut_destroy(PR_RECBUT *self)
    {
    p_free(self->recbut.buttxt);
    p_supersend2(self,O_DESTROY);
    }

METHOD VOID recbut_rb_init(PR_RECBUT *self,INT wid,P_POINT *pc,INT rid)
    {
    self->recbut.wid=wid;
    self->recbut.rect.tl.x=pc->x-RECBUT_HALF_WIDTH;
    self->recbut.rect.br.x=pc->x+RECBUT_HALF_WIDTH;
    self->recbut.rect.tl.y=pc->y-RECBUT_HALF_HEIGHT;
    self->recbut.rect.br.y=pc->y+RECBUT_HALF_HEIGHT;
    hLoadResource(rid,&self->recbut.buttxt);
    self->recbut.inlabel=(TEXT *)(((WORD *)self->recbut.buttxt)+1);
    self->recbut.caption=NextZTS(self->recbut.inlabel);
    self->recbut.caplen=p_slen(self->recbut.caption);
    }

METHOD VOID recbut_rb_draw(PR_RECBUT *self)
    {
    P_RECT r;

    if (self->recbut.hide==RECBUT_HIDE_HIDE)
        return;
    r.tl.x=self->recbut.rect.tl.x-RECBUT_MARGIN;
    r.br.x=self->recbut.rect.br.x+RECBUT_MARGIN;
    r.br.y=self->recbut.rect.tl.y;
    r.tl.y=r.br.y-(2*RECBUT_HALF_HEIGHT);
    if (self->recbut.hide==RECBUT_HIDE_CLEAR)
        {
        gClrRect(&r,G_TRMODE_CLR);
        gClrRect(&self->recbut.rect,G_TRMODE_CLR);
        return;
        }
    DrawButton(self,0);
    gPrintBoxText(&r,RECBUT_ASCENT,G_TEXT_ALIGN_CENTRE,0,self->recbut.caption,self->recbut.caplen);
    }

METHOD VOID recbut_rb_depress(PR_RECBUT *self)
    {
    gCreateTempGC0(self->recbut.wid);
    DrawButton(self,2);
    wFlush();
    p_sleep(2L);
    DrawButton(self,0);
    wFlush();
    gFreeTempGC();
    }

METHOD VOID recbut_rb_hide(PR_RECBUT *self,INT hide)
    {
    self->recbut.hide=hide;
    }

METHOD VOID reccli_destroy(PR_RECCLI *self)
    {
    p_free(self->reccli.clitxt);
    p_supersend2(self,O_DESTROY);
    }

METHOD VOID reccli_wn_connect(PR_RECCLI *self,PR_WIN *par,UINT fields,W_WINDATA *pwd)
    {
    INT i,dx;
    P_POINT c;
    P_RECT rect;
    E_CONFIG config;

    p_getctd(&config);
    self->reccli.tsep=config.timeSeparator;
    self->reccli.width=pwd->extent.width;
    pwd->background=W_WIN_BACK_CLR|W_WIN_BACK_GREY_CLR;
    p_supersend5(self,O_WN_CONNECT,par,fields|W_WIN_BACKGROUND,pwd);
    hInitVis(self);
    p_send3(self,O_WN_EMPHASISE,TRUE);
    rect.tl.x=12;
    rect.br.x=self->reccli.width-rect.tl.x;
    rect.tl.y=74;
    rect.br.y=rect.tl.y+TIMEBAR_HEIGHT;
    self->reccli.timebar=f_newsend(CAT_RECORD_RECORD,C_TIMEBAR,O_AO_INIT,self->win.id,&rect);
    dx=(self->reccli.width-6)/6;
    c.y=130;
    for (i=0;i<RECCLI_NBUTTONS;i++)
        {
        c.x=3+dx+(((i<3)?i*dx:dx)<<1);
        self->reccli.recbut[i]=f_newsend(CAT_RECORD_RECORD,C_RECBUT,O_RB_INIT,self->win.id,&c,CLIBUT_REC_NEW+i);
        }
    HideButtons(self,RECCLI_STOP_MASK|RECCLI_START_MASK);
    hLoadResource(RECCLI_TEXT,&self->reccli.clitxt);
    self->reccli.secs=(TEXT *)(((WORD *)self->reccli.clitxt)+1);
    self->reccli.title=NextZTS(self->reccli.secs);
    self->reccli.sub=NextZTS(self->reccli.title);
    wValidateWin(self->win.id); /* saves screen flicker on startup */
    }

METHOD VOID reccli_wn_draw(PR_RECCLI *self)
    {
    INT i,len,y;
    WVEFILE_INFO info;
    TEXT name[16];
    TEXT duration[20],total[20];
    G_GC gc;

    p_supersend(self,O_WN_DRAW); /* draw border */
    p_send2(self->reccli.timebar,O_TB_DRAW); /* draw time bar */
    /* draw buttons */
    for (i=0;i<RECCLI_NBUTTONS;recbut_rb_draw(self->reccli.recbut[i++]));
    p_send3(receng,O_ENG_FILE_INFO,&info);
    *p_bcpy(&name[0],info.name,len=info.nmlen)=0;
    p_scap(&name[0]);
    if (*info.device!='M')
        {
        name[len++]='[';
        name[len++]=*info.device;
        name[len++]=']';
        }
    name[len]=0;
    gc.style=G_STY_BOLD;
    gc.font=FONT_ID_SWISS_16;
    gSetGC(0,G_GC_MASK_STYLE|G_GC_MASK_FONT,&gc);
    y=8;
    if (info.duration)
        {
        PrintDuration(self,&duration[0],(LONG)info.duration);
        /* %s   %s   %d Kbyte */
        PrintHeader(self,y,self->reccli.title,&name[0],&duration[0],(INT)(info.flen>>10));
        }
    else 
        PrintHeader(self,y,"%s",&name[0]); /* might be a % character in name[] */
    y=40;
    if (info.repeats<=1 && info.silence==0)
        {
        PrintHeader(self,y,NULL); /* clear rectangle */
        return;
        }
    gc.style=G_STY_NORMAL;
    gc.font=FONT_ID_SWISS_13;
    gSetGC(0,G_GC_MASK_STYLE|G_GC_MASK_FONT,&gc);
    PrintDuration(self,&duration[0],(LONG)info.silence);
    PrintDuration(self,&total[0],info.total);
    /* Repeats: %d    Trailing silence: %s    Total: %s */
    PrintHeader(self,y,self->reccli.sub,info.repeats,&duration[0],&total[0]);
    }

METHOD VOID reccli_cl_update(PR_RECCLI *self)
    {
    p_send2(self->reccli.timebar,O_TB_STOP);
    self->reccli.running=FALSE;
    w_ws->wserv.filter=NULL;
    wDisableKeyClick(FALSE);
    HideButtons(self,RECCLI_STOP_MASK|RECCLI_START_MASK);
    DrawWin(self);
    wFlush();
    }

METHOD VOID reccli_wn_key(PR_RECCLI *self,UINT keycode,UINT modifiers)
    {
    switch (keycode)
        {
    case W_KEY_TAB:
        recbut_rb_depress(self->reccli.recbut[0]);
        hWservComSend(O_COM_RECORD_NEW);
        break;
    case ' ':
        recbut_rb_depress(self->reccli.recbut[1]);
        hWservComSend(O_COM_RE_RECORD);
        break;
    case W_KEY_RETURN:
        recbut_rb_depress(self->reccli.recbut[2]);
        p_send2(receng,O_ENG_SOUND_PLAY);
        break;
        }
    }

METHOD INT reccli_cl_sound_filter(PR_RECCLI *self,UINT keycode,UINT modifiers)
    {
    if (keycode==W_KEY_ESCAPE)
        {
        p_send2(receng,O_ENG_SOUND_STOP);
        recbut_rb_depress(self->reccli.recbut[3]);
        }
    return(WN_KEY_CHANGED);
    }

METHOD INT reccli_cl_pause_filter(PR_RECCLI *self,UINT keycode,UINT modifiers)
/*
Waiting to record.
*/
    {
    if (keycode==W_KEY_ESCAPE)
        p_send3(receng,O_ENG_OPEN_FILE,NULL);
    else if (keycode==' ')
        {
        w_ws->wserv.filter=NULL;
        p_send3(receng,O_ENG_SOUND_RECORD,self->reccli.duration);
        }
    return(WN_KEY_CHANGED);
    }

METHOD VOID reccli_cl_begin_sound(PR_RECCLI *self,ULONG *tenths)
    {
    p_send3(self->reccli.timebar,O_TB_START,tenths);
    self->reccli.running=TRUE;
    w_ws->wserv.filter=(PR_WIN *)self;
    w_ws->wserv.filmethod=-O_CL_SOUND_FILTER;
    wDisableKeyClick(TRUE);
    HideButtons(self,RECCLI_3BUT_MASK|RECCLI_START_MASK);
    DrawWin(self);
    wFlush();
    }

METHOD VOID reccli_cl_pause(PR_RECCLI *self,UINT duration)
    {
    self->reccli.duration=duration;
    w_ws->wserv.filter=(PR_WIN *)self;
    w_ws->wserv.filmethod=-O_CL_PAUSE_FILTER;
    HideButtons(self,RECCLI_3BUT_MASK|RECCLI_STOP_MASK);
    DrawWin(self);
    wFlush();
    }

METHOD VOID recman_am_clean_up(PR_RECMAN *self,INT err,UBYTE *htask)
    {
    PR_RECCLI *cli;

    cli=(PR_RECCLI *)w_ws->wserv.cli;
    w_ws->wserv.filter=NULL;
    wDisableKeyClick(FALSE);
    p_send2(cli->reccli.timebar,O_TB_STOP);
    p_supersend4(self,O_AM_CLEAN_UP,err,htask);
    p_send3(receng,O_ENG_OPEN_FILE,NULL);
    }